Optimizing license use for software license attribution

ABSTRACT

In one embodiment, a system for license management includes logic adapted for arranging entitlement slots under a plurality of licenses, each entitlement slot being configured for affording entitlement to use of an instance of a software application during a particular time frame, logic adapted for determining a license use signature from recorded license attribution information, logic adapted for receiving a notification of an instance not attributed to a license, and logic adapted for attributing the non-attributed instance to one of the plurality of licenses as a function of the license use signature, wherein each license has an entitlement value defining a maximum number of entitlement slots that may be attributed to that license during the time frame and any given instance of the software application may consume any number of the entitlement slots including zero entitlement slots.

RELATED APPLICATIONS

This application claims priority to PCT Patent Application No. PCT/EP2010/060306, filed Jul. 16, 2010, and from European Patent Application No. EP09167398.8 filed on Aug. 6, 2009, which is herein incorporated by reference.

BACKGROUND

The present invention relates to license management, and more particularly, this invention relates to license management for software license attribution.

Software is generally protected by copyright law, and any use of software whose copyright is not the property of the user is dependent on a license from the copyright owner. Such licenses generally impose restrictions on the way in which the software may be used, in particular some items that may be restricted may include the number of concurrent users that may use the software on a given system at one time, the number of machines on which the software may be installed, etc.

Of course, payment is generally required for a license, and in some cases ongoing payments may be required depending on the extent and nature of the use of the software, particularly in how it relates to the restrictions. Still further, it may be possible to obtain alternative license terms in a case where use evolves over time so that a particular license no longer satisfactorily covers the current or expanded use of the software. In enterprise environments with large numbers of users and machines on one hand, and a variety of different payment or royalty mechanisms on the other hand, the association of a particular license with a particular use may become increasingly complex. In such situations, it is customary to provide license management software configured to monitor software usage.

Recent descriptions of license management software apply a number of different methods to associate software installation or use with the most appropriate of several valid licenses for the software in question. The objective of these methods is to optimise the use of licenses in order to remain compliant with the terms and conditions without having to over-procure and pay more for the use of the licenses than is necessary.

WIPO Publication No. WO08052820A1 discloses a method and a corresponding apparatus for controlling and metering usage of software products on a computer. When several licenses are available for the same product, a method for determining the best license is proposed in order to maximize the exploitation of the licenses. Such a determination is based on a predetermined set of parameters which influence the selection of the best available license. The licenses are stored on a catalogue with an associated list of parameters indicative of usage constraints of the product. The licenses are ordered according to predetermined parameters optimization criteria, so that when a request is received, the license manager may easily find the best license, e.g., that license, suitable for the requested use, having the highest usage constraint. An additional feature is that the licenses are ordered

This method, such as when two licenses have similar characteristics, applies a simple approach, trying to evenly distribute usage sessions between the licenses.

The disadvantage of all of these methods is that the choice is based on fixed rules, driven by an attempt to make the best choice. In real-world scenarios, the use of software may be very different from the logic assumed in the rules, and the method may make choices that lead to out-of-compliance or a non-optimized license use.

SUMMARY

In one embodiment, a system for license management includes logic adapted for arranging entitlement slots under a plurality of licenses, each entitlement slot being configured for affording entitlement to use of an instance of a software application during a particular time frame, logic adapted for determining a license use signature from recorded license attribution information, logic adapted for receiving a notification of an instance not attributed to a license, and logic adapted for attributing the non-attributed instance to one of the plurality of licenses as a function of the license use signature, wherein each license has an entitlement value defining a maximum number of entitlement slots that may be attributed to that license during the time frame and any given instance of the software application may consume any number of the entitlement slots including zero entitlement slots.

In another embodiment, a computer program product for license management includes a non-transitory computer readable storage medium having computer readable program code embodied therewith, the computer readable program code including computer readable program code configured for arranging entitlement slots under a plurality of licenses, each entitlement slot being configured for affording entitlement to use of an instance of a software application during a particular time frame, computer readable program code configured for determining a license use signature from recorded license attribution information, computer readable program code configured for receiving a notification of an instance not attributed to a license, and computer readable program code configured for attributing the non-attributed instance to one of the plurality of licenses as a function of the license use signature, wherein each license has an entitlement value defining a maximum number of entitlement slots that may be attributed to that license during the time frame and any given instance of the software application may consume any number of the entitlement slots including zero entitlement slots.

In yet another embodiment, a method for license management includes arranging entitlement slots under a plurality of licenses, each entitlement slot being configured for affording entitlement to use of an instance of a software application during a particular time frame, determining a license use signature from recorded license attribution information by determining a probability for each of the plurality of licenses that an arbitrary instance will be chargeable according to that license and determining for each of the plurality of licenses an average number of slots consumed per instance, wherein the license use signature represents typical license use patterns, receiving a notification of an instance not attributed to a license, and attributing the non-attributed instance to one of the plurality of licenses as a function of the license use signature, wherein each license has an entitlement value defining a maximum number of entitlement slots that may be attributed to that license during the time frame, and any given instance of the software application may consume any number of the entitlement slots including zero entitlement slots.

Other aspects and embodiments of the present invention will become apparent from the following detailed description, which, when taken in conjunction with the drawings, illustrate by way of example the principles of the invention.

BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS

FIG. 1 illustrates a network architecture, in accordance with one embodiment.

FIG. 2 shows a representative hardware environment that may be associated with the servers and/or clients of FIG. 1, in accordance with one embodiment.

FIG. 3 is a flowchart of a method, according to one embodiment.

FIG. 4 is a detailed flowchart of a method, according to another embodiment.

FIG. 5 is a flowchart of a method, according to one embodiment.

FIG. 6 shows a schematic block diagram of functional elements of some embodiments.

FIG. 7 shows a computer environment suitable for implementing embodiments described herein.

DETAILED DESCRIPTION

The following description is made for the purpose of illustrating the general principles of the present invention and is not meant to limit the inventive concepts claimed herein. Further, particular features described herein can be used in combination with other described features in each of the various possible combinations and permutations.

Unless otherwise specifically defined herein, all terms are to be given their broadest possible interpretation including meanings implied from the specification as well as meanings understood by those skilled in the art and/or as defined in dictionaries, treatises, etc.

It must also be noted that, as used in the specification and the appended claims, the singular forms “a,” “an” and “the” include plural referents unless otherwise specified.

According to one embodiment, for environments where there exists a choice of software licenses offering a variety of different terms and restrictions, there is described a method of selection of a preferred license on the basis of historical use patterns. Preferably, a new instance is attributed to whichever license has the lowest probability that an arbitrary instance will be chargeable according to that license (C), and where the probability for that license that a new instance will be chargeable according to that license (C) multiplied by the average number of slots consumed per instance (S) for that license multiplied by the number of number of instances already attributed to that license during the present time frame (1) is less than the entitlement value for that license.

In one general embodiment, a system for license management includes logic adapted for arranging entitlement slots under a plurality of licenses, each entitlement slot being configured for affording entitlement to use of an instance of a software application during a particular time frame, logic adapted for determining a license use signature from recorded license attribution information, logic adapted for receiving a notification of an instance not attributed to a license, and logic adapted for attributing the non-attributed instance to one of the plurality of licenses as a function of the license use signature, wherein each license has an entitlement value defining a maximum number of entitlement slots that may be attributed to that license during the time frame and any given instance of the software application may consume any number of the entitlement slots including zero entitlement slots.

In another general embodiment, a computer program product for license management includes a non-transitory computer readable storage medium having computer readable program code embodied therewith, the computer readable program code including computer readable program code configured for arranging entitlement slots under a plurality of licenses, each entitlement slot being configured for affording entitlement to use of an instance of a software application during a particular time frame, computer readable program code configured for determining a license use signature from recorded license attribution information, computer readable program code configured for receiving a notification of an instance not attributed to a license, and computer readable program code configured for attributing the non-attributed instance to one of the plurality of licenses as a function of the license use signature, wherein each license has an entitlement value defining a maximum number of entitlement slots that may be attributed to that license during the time frame and any given instance of the software application may consume any number of the entitlement slots including zero entitlement slots.

In yet another general embodiment, a method for license management includes arranging entitlement slots under a plurality of licenses, each entitlement slot being configured for affording entitlement to use of an instance of a software application during a particular time frame, determining a license use signature from recorded license attribution information by determining a probability for each of the plurality of licenses that an arbitrary instance will be chargeable according to that license and determining for each of the plurality of licenses an average number of slots consumed per instance, wherein the license use signature represents typical license use patterns, receiving a notification of an instance not attributed to a license, and attributing the non-attributed instance to one of the plurality of licenses as a function of the license use signature, wherein each license has an entitlement value defining a maximum number of entitlement slots that may be attributed to that license during the time frame, and any given instance of the software application may consume any number of the entitlement slots including zero entitlement slots.

As will be appreciated by one skilled in the art, aspects of the present invention may be embodied as a system, method or computer program product. Accordingly, aspects of the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as “logic,” a “circuit,” “module,” or “system.” Furthermore, aspects of the present invention may take the form of a computer program product embodied in one or more computer readable medium(s) having computer readable program code embodied thereon.

Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium may be a computer readable signal medium or a non-transitory computer readable storage medium. A non-transitory computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the non-transitory computer readable storage medium include the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a portable compact disc read-only memory (CD-ROM), a Blu-ray disc read-only memory (BD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a non-transitory computer readable storage medium may be any tangible medium that is capable of containing, or storing a program or application for use by or in connection with an instruction execution system, apparatus, or device.

A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may be any computer readable medium that is not a non-transitory computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device, such as an electrical connection having one or more wires, an optical fibre, etc.

Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fibre cable, RF, etc., or any suitable combination of the foregoing.

Computer program code for carrying out operations for aspects of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++, or the like, and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may execute entirely on a user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer or server may be connected to the user's computer through any type of network, including a local area network (LAN), storage area network (SAN), and/or a wide area network (WAN), or the connection may be made to an external computer, for example through the Internet using an Internet Service Provider (ISP).

Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatuses (systems), and computer program products according to various embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, may be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer readable medium that may direct a computer, other programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions stored in the computer readable medium produce an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks.

The computer program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.

FIG. 1 illustrates a network architecture 100, in accordance with one embodiment. As shown in FIG. 1, a plurality of remote networks 102 are provided including a first remote network 104 and a second remote network 106. A gateway 101 may be coupled between the remote networks 102 and a proximate network 108. In the context of the present network architecture 100, the networks 104, 106 may each take any form including, but not limited to a LAN, a WAN such as the Internet, public switched telephone network (PSTN), internal telephone network, etc.

In use, the gateway 101 serves as an entrance point from the remote networks 102 to the proximate network 108. As such, the gateway 101 may function as a router, which is capable of directing a given packet of data that arrives at the gateway 101, and a switch, which furnishes the actual path in and out of the gateway 101 for a given packet.

Further included is at least one data server 114 coupled to the proximate network 108, and which is accessible from the remote networks 102 via the gateway 101. It should be noted that the data server(s) 114 may include any type of computing device/groupware. Coupled to each data server 114 is a plurality of user devices 116. Such user devices 116 may include a desktop computer, laptop computer, handheld computer, printer, and/or any other type of logic-containing device. It should be noted that a user device 111 may also be directly coupled to any of the networks, in some embodiments.

A peripheral 120 or series of peripherals 120, e.g., facsimile machines, printers, scanners, hard disk drives, networked and/or local storage units or systems, etc., may be coupled to one or more of the networks 104, 106, 108. It should be noted that databases and/or additional components may be utilized with, or integrated into, any type of network element coupled to the networks 104, 106, 108. In the context of the present description, a network element may refer to any component of a network.

According to some approaches, methods and systems described herein may be implemented with and/or on virtual systems and/or systems which emulate one or more other systems, such as a UNIX system which emulates an IBM z/OS environment, a UNIX system which virtually hosts a MICROSOFT WINDOWS environment, a MICROSOFT WINDOWS system which emulates an IBM z/OS environment, etc. This virtualization and/or emulation may be enhanced through the use of VMWARE software, in some embodiments.

In more approaches, one or more networks 104, 106, 108, may represent a cluster of systems commonly referred to as a “cloud.” In cloud computing, shared resources, such as processing power, peripherals, software, data, servers, etc., are provided to any system in the cloud in an on-demand relationship, thereby allowing access and distribution of services across many computing systems. Cloud computing typically involves an Internet connection between the systems operating in the cloud, but other techniques of connecting the systems may also be used, as known in the art.

FIG. 2 shows a representative hardware environment associated with a user device 116 and/or server 114 of FIG. 1, in accordance with one embodiment. FIG. 2 illustrates a typical hardware configuration of a workstation having a central processing unit 210, such as a microprocessor, and a number of other units interconnected via a system bus 212, according to one embodiment.

The workstation shown in FIG. 2 includes a Random Access Memory (RAM) 214, Read Only Memory (ROM) 216, an I/O adapter 218 for connecting peripheral devices such as disk storage units 220 to the bus 212, a user interface adapter 222 for connecting a keyboard 224, a mouse 226, a speaker 228, a microphone 232, and/or other user interface devices such as a touch screen, a digital camera (not shown), etc., to the bus 212, communication adapter 234 for connecting the workstation to a communication network 235 (e.g., a data processing network) and a display adapter 236 for connecting the bus 212 to a display device 238.

The workstation may have resident thereon an operating system such as the MICROSOFT WINDOWS Operating System (OS), a MAC OS, a UNIX OS, etc. It will be appreciated that a preferred embodiment may also be implemented on platforms and operating systems other than those mentioned. A preferred embodiment may be written using JAVA, XML, C, and/or C++ language, or other programming languages, along with an object oriented programming methodology. Object oriented programming (OOP), which has become increasingly used to develop complex applications, may be used.

In order to more efficiently deal with the problems of currently used license management techniques, a method to dynamically select the best applicable license for a given instance of an act (such as running an instance of an application, program, etc.) may be used, according to one embodiment, so that when an application starts, the best licenses, at the time the application is started, may be assigned to the application. During the lifetime of the application, the best license may change or the used license may be no longer applicable. For example, a license which was in use at the time the application was started may be released at a certain time, so it becomes the best available license after the application was started. In another example, the original license may no longer be used because it is changed in some way, for example by adding additional limitations or restrictions to it, such that it is no longer applicable to the operating system (OS) the application is running on. According to another example, something may change in the hardware configuration or the organizational hierarchy, e.g., the OS hosting the application may be moved from one department to another department, thus making the original license no longer applicable or making another license the best available one, the hardware hosting the OS where the application is running may be upgraded (without stopping the application) thus making the license no longer applicable. Of course, many other possibilities may occur that are not specifically described herein, but which may result in the first assigned license no longer being the best license to use.

The examples presented above are simple examples of a change to the license properties, hardware (i.e., resource) properties, properties of the organization (i.e., group properties) or properties of the link between any of these entities. These changes may result in another license becoming the best license to assign.

An embodiment is described hereafter in the context of a complete license interpretation system, although it is to be appreciated that embodiments described herein may equally be implemented in simpler, more complicated, or otherwise different environments, or even as an entirely stand-alone solution. How the embodiments described herein are implemented is not intended to be limited by the examples and descriptions included herein.

Organizations are generally divided into hierarchies representing geographical or organizational divisions of an enterprise or business. Licenses may be acquired or assigned at different levels of these hierarchies. For this reason, these hierarchies may preferably be taken into account when deciding which is the best license to assign to an instance of an application.

In one example, a license interpretation system may accept the following inputs: An abstraction of the licensee organization based on hierarchies: one hierarchy may be a geographical grouping (continent, region, state, city, etc.), while another hierarchy may be an organizational grouping (development lab, code development team, Java development department, etc.). A set of group hierarchies (where each group is differently divided) may be defined. Each hierarchy has its own identifier, which makes it possible to distinguish the groups that are part of each hierarchy apart from one another. A group in a hierarchy may have a parent in the same hierarchy and may be linked (as a child) to at most one group of other hierarchies at any point in time and/or level of the hierarchy. The hierarchy identifiers generate a ranking of the hierarchies: a group in one hierarchy may be associated (as a child) only to groups of hierarchies of higher rank, in one approach.

Another hierarchy may include virtualization layers, where each node is a root of such hierarchies, and its child may be, for example, shared pools, Logical Partitions (LPARs), virtual machines (VMs), OSs, containers (as provided by IBM WEBSPHERE), etc. Each member of such hierarchies is a resource. A resource is linked to its parent resource (the roots being nodes) and may also be linked to at most one group of each group hierarchies. A resource may have one parent and be linked to one group of each hierarchy at any given point in time, meaning that at two different times, it may have two different resource parents or linked groups in the same hierarchy, according to one approach.

Every link between resources, groups, and/or resources and groups may be tagged with a validity time interval in such a way that, for example, the department license manager may be part of the development lab during a first period of time and may be moved, for example, to the research lab during a second period of time. In another example, an OS may have been hosted on a first machine for a first period of time and then may be moved to machine B for a second period of time, for example to upgrade the machine on which the OS is running.

Each resource or group may be associated with certain properties, according to one embodiment. The properties may depend on the ability of the licensing system to retrieve useful data about each entity. For example, the number of processors of a node, the amount of memory of an operating system, the number of employees in a department, or any other useful information may be used. These properties may be collected in one approach because a pricing model may potentially use them for computing how much a license has been used (for example, certain licenses require capacity information at each level of the virtualization hierarchy to compute software usage).

Another possible input of the algorithm is the set of users known to the licensing system. These users are the ones installing or executing software and can also be used to limit license consumption only to a subset of the enterprise employees. Each user can be tagged with additional properties, describing any attribute of the user the licensing system is able to retrieve and which can be useful to some pricing model for license computation.

Still another possible input is a set of licenses, each one associated to one pricing model supported by the licensing system. Each license may be potentially divided into multiple distributions, i.e., divisions of the license entitlement, each one associated to different subjects allowed to use the license. Each distribution has a set of targets allowed to use this distribution (being them groups or resources) and for each of these targets one or more association validity intervals are provided meaning that the targets are allowed to use the license only in these time intervals. Also, each distribution may be associated with all the users or a subset of them, thus limiting the users which can use it. Again, each of these associations are augmented with one or more time intervals, detailing the association validity.

Countless variations in license terms may be used, for example: a license usable to any employee in the Development lab (the target is the group representing the Development lab, while, there are no user limitations); a license usable to any employee in Italy (the target is the group representing the geographical location Italy, as there are no user limitations); a license usable only on a particular hardware system (such as on a particular PC), where the target is the resource representing the particular hardware, while there are no user limitations; a license usable only by a named user, as the target is the whole enterprise, but there is a user limitation, associating the license only to one user.

Of course, each license and distribution has associated properties which are values entered by the user when defining the license and the distribution, and required by the pricing model associated to the licenses for computing license usage and compliance. Examples of these are the number of processors the application is executed on, or multiple numbers for licenses such as tier licenses, where each number is for a different hardware tier and so on.

To ensure a good association of usage to license, the licensing system supports the concept of non-consuming licenses: a license (or pricing model) may be flagged as not consuming if the user has to pay the same amount for the license independent of the amount of software usage. For example, a site license for a given product for the use of a particular development group is a good example of a non-consuming license: the lab pays for the license when acquiring it and once paid, the lab may use that product as often as desired without the need to pay additional fees and without risking overuse of the license. If such a license is available for a product, it is considered as a preferred license because use may be associated to it without risking overuse or the need to pay additional fees (such as in pay-per-use licenses).

The license interpretation system according to one embodiment executes the following operations 1-6:

1. Navigate the resource and group hierarchies, starting from the resource which originated the software usage, extracting the set of license distribution reachable from that resource in each time interval and associated to the product generating the consume session, that is, the instance of the software for which it may be necessary to associate a usage slot.

The resource hierarchy is the first one to be visited. The parent of each resource is visited after the resource itself. In case of multiple parents, they may be visited in time order (but this is not strictly required for the correctness of the algorithm). While visiting the resources, the algorithms collect the list of groups reachable from each resource. After completing the visit of the resource hierarchy, the algorithm moves to the group hierarchies starting from the ones with lower rank (i.e., highest ID). During the visit, a reachable time interval may be maintained.

2. Select the validity time of each license based on user limits. If the license (or distribution) has no user limits, it may be associated to the consume session at any time. Otherwise, the license (or distribution) cannot be associated in the time periods where the consume session user is not associated with the license (or distribution). This operation may be performed before operation 1, since the two are independent.

3. For all the licenses (or distributions) which may be associated with the consume session, determine if the pricing model allows for the session to be assigned and in what time intervals. There are some pricing models which impose additional constraints on consume sessions to be associated, such as pricing models which allow a consume session to be associated with a license (or distribution) only if a specified second product is also installed on the machine; otherwise the license cannot be used. So the association is possible only during the time intervals where the referenced product is also installed on the machine.

4. Once the algorithm has obtained the list of licenses associable to a consume session with the related time intervals, the algorithm prefers non-consuming licenses.

5. If no valid license is found, based on the target constraints, the algorithm searches for licenses (or distributions) marked as “default” and reachable from the root of all the hierarchies within the time interval for reach ability. The nearest license (or distribution) associated to the product originating the consume session is considered as the first one valid for the association.

6. If more than two licenses (or distributions) are obtained for a given time interval (because two of them are associated to the same resource or group) the algorithm prefers installation licenses (or distributions) over usage licenses (or distributions).

It will be understood to those of skill in the art that other methods of automatically interpreting, selecting, and applying license terms are equally compatible with the embodiments described herein.

A license management system seeks to evenly distribute usage sessions between the licenses, without consideration of the expected consumption for each license. However, embodiments described herein are based on the realization that the license management system already has a database that includes software inventory and use information. The data may date back several months, or even years. Recent historical data is a good indicator of typical use patterns, and it may be assumed that software use on any particular day is likely to match the pattern observed in the past week, 2 weeks, or any other appropriately recent period. The license management system uses the knowledge about how many software instances are typically used in the various branches of the organization, and what that means in terms of license use for the licenses that are applicable to any particular piece of software, to be able to distribute current use among the licenses in an optimized fashion, choosing the most appropriate license for each use in order to optimize use of most “convenient” license and ensure that none of the licenses go into non-compliance.

Accordingly, if there are two installation or usage licenses (or distributions), or if it is necessary in any other context to choose between two licenses, the algorithm uses historical usage data to determine which is the best license to use. This logic is based on statistical indicators derived from the data the system accumulated over time. Accordingly, there is provided a method of attributing entitlement slots under a plurality of software licenses potentially affording rights to a particular piece of software or application to instances of this piece of software or application during a particular time frame, where each license has an entitlement value (E) defining the maximum number of entitlement slots that may be attributed to that license during this time frame. This method is described more fully in FIG. 5, according to one embodiment.

Preferably, the model represents typical license use patterns, and the method attributes the new instance to the most convenient of the licenses while ensuring compliance with terms of all the licenses.

The time frame may be a fraction of an hour, one or more hours, days, weeks, etc., or any other period as defined in the licenses being used. If desired, the time frame may be a fraction of the period defined in the license. Slots may be distributed amongst time frames, and unused time frames passed to later time frames within the same license period. The time frame may be chosen as the lowest common denominator of the period of the various licenses applicable to the same software, in one approach.

For the purposes of the following example, it is assumed that the time frame is one day, and that there exists a plurality of licenses covering the same software or application from a functional point of view. Each of these licenses defines a number of entitlement slots (E) that may be consumed in a given day, where each entitlement slot corresponds to executing the software once on a single processor, that is, one software instance. Where the same software is run once on a multiprocessor system, the number of entitlement slots consumed may be multiplied by the number of processors in that system. That is, the number of entitlement slots consumed by a particular instance may depend on the number of processors on which the instance is executed. Certain licenses may require that an entitlement slot be consumed only for the first execution in a given day, any following executions attributed to the same license simply falling into the same entitlement slot. Naturally, a vast range of variations and permutations along these lines may be envisaged.

The following values may be considered:

dC=for a given license, the total number of entitlement slots consumed on a particular day, as determined from historic use data.

dN=for a given license, the number of charging software instances attributed to that license on a particular day. A charging software instance is an instance which results in the consumption of at least one entitlement slot.

dL=for a given license, the number of software instances attributed to that license on a particular day. This value takes into account all attributed instances, whether they result in the consumption of entitlement slots or not.

It is understood that for a given license, dN will always be less than or equal to dL.

Day d-2:

license 1 (E = 4) license 2 (E = 10) 2 2 0 2 3 1 dC = 2 dC = 8 dN = 1 dN = 4 dL = 2 dL = 4

Day d-1:

license 1 (E = 4) license 2 (E = 10) 2 4 0 2 0 0 dC = 2 dC = 6 dN = 1 dN = 2 dL = 4 dL = 2

From historical information, as shown by way of example in the preceding tables for day d-1 and d-2, a value C is calculated, where:

C=AVG (dC/dN), the average of the ratio between how much a license is consumed and the number of consuming instances. This value represent the average consume of a software or application instance with a non-zero contribution.

S=AVG (dN/dL), the average of the probability that a software instance associated to a license has a non-zero effect on the license consumption.

Day d-2:

license 1 (E = 4) license 2 (E = 10) dC = 2 dC = 8 dN = 1 dN = 4 dL = 2 dL = 4 dC/dN = 2/1 = 2 dC/dN = 8/4 = 2 dN/dL = 1/2 dN/dL = 4/4 = 1

Day d-1:

license 1 (E = 4) license 2 (E = 10) dC = 2 dC = 6 dN = 1 dN = 2 dL = 4 dL = 2 dC/dN = 2/1 = 2 dC/dN = 6/4 = 3/2 dN/dL = 1/4 dN/dL = 2/2 = 1

Average Values:

license 1 (E = 4) license 2 (E = 10) C = (2 + 2)/2 = 2 C = (2 + 3/2)/2 = 7/4 S = ((1/2) + (1/4)) = 3/8 S = (1 + 1)/2 = 1

Turning now to day d, that is, “today,” a partially complete day for which license attribution optimization, according to embodiments presented herein, is implemented.

R(n)=E−N×C×S is the average residual capacity after n instances have been assigned to the license.

Day d:

license 1 (E = 4) license 2 (E = 10) 4 4 C = 2 C = 7/4 S = 3/8 S = 1 N = 4 N = 4 R = 4 − (4 × 2 × (3/8)) = 4 − 3 = 1 R = 10 − (4 × 7/4 × 1) = 10 − 7 = 3

As shown above, so far 4 slots of each license have been attributed to each license. When a further consuming instance is detected, it is determined to which license it should be attributed by reference to the historical values calculated as described above. Specifically, when the system chooses among two or more licenses, it assigns an instance to the license with the lower C and an R higher than 0, in one approach.

In the present example, both licenses have an R higher than 0, but license 1 has the lower value of C, so that the next consuming instance is attributed to license 1.

According to certain embodiments described herein, license 2 may be used until there are R available ((7/4)*3=5 instances), after which license 1 may be used even though it has a higher C.

Accordingly, the step of determining a license use signature may comprise the steps of determining from recorded license attribution information a probability for each said license that an arbitrary instance will be chargeable according to that license (C), and determining from recorded license attribution information for each said license an average number of slots consumed per instance (S). The step of attributing may comprise the steps of: attributing the new instance to whichever license has the lowest probability that an arbitrary instance will be chargeable according to that license (C), and where the probability for that license that a new instance will be chargeable according to that license (C) multiplied by the average number of slots consumed per instance (S) for that license multiplied by the number of number of instances already attributed to that license during the present time frame (I) is less than the entitlement value for that license.

Still further, the probability for each license that an arbitrary instance will be chargeable according to that license (C) is preferably calculated as the average across all time frames in the historical record of the ratio between the number of slots consumed on each time frame comprised in the historical record (dC) and the number of instances to which slots are attributed in that same time frame (dN).

The average number of slots consumed per instance (S) is preferably calculated as the average across all time frames in the historical record of the ratio between the number of instances to which slots are attributed in each time frame (dN) and the total number of instances with that license in the same time frame (dN).

If the number of instances assigned to a particular license exceeds its Entitlement value (E), the system's use is improper. One way of preventing this situation may be to impose a hard limit, such that the license attribution system may not attribute instances to licenses that have reached their entitlement limit. This may however lead to the impossibility of assigning any license, or prevent the software from running altogether.

An alternative, which results in a more graceful handling of licenses in high demand, calls for the application of a protection threshold P to the entitlement giving E=E*P/100). In this way, a safety margin is built into the calculation to avoid overloading a particular license. Accordingly, the respective entitlement value (E) may be multiplied by a predefined protection threshold value (P) such that the entitlement value (E) becomes less than the strict maximum defined by each license.

It will be noted that the values chosen in the foregoing example very small, for the sake of simplicity, for which it would in any case be a simple matter to identify the most appropriate license without recourse to embodiments described herein. It will be appreciated that the embodiments described herein become increasingly useful as the number and complexity of licenses and usage instances increases.

In this way, the association of software use to the most appropriate license, based on a knowledge of how the organization actually uses the software is improved, and the risk of making a non-optimized choice is thereby reduced.

Furthermore, association between software usage and licenses justifying that usage may be provided in the presence of complex organizational and virtualization hierarchies, while maintaining a method general enough to support very different pricing models. The license association logic should maximize the usage of existing licenses and avoid each of them to reach overuse (e.g., usage greater than the entitlement level).

FIG. 3 is a schematic representation of a method 300 according to one embodiment. The method 300 allows handling of complex organizational structures and virtualization hierarchies by preferring non-consuming licenses over consuming licenses, thus optimising the license association. It also allows license use signature specific constraints to be included in the association processing, thus supporting different pricing models and their constraints.

This approach may be extended to product hierarchies by considering all the licenses associated not to the product originating the consume session, but to all the products in the hierarchy of the consuming one, in one approach.

The method 300 of ordering the preferred licenses according to a mix of their distance from the consuming resource and the relative order of hierarchies is just one of several possibilities. One alternative may be to combine all the attributes, such as with a relative weight, and calculating a global “preference value” for each license. Other ways of determining what is a preferred license may also be used, according to other approaches.

As shown in FIG. 3, a method 300 may include any number of operations or steps. The method 300 may begin at the beginning of a new time frame, and proceeds to operation 305 after initialization, where the value N is set to zero for each license. As described above, N is the number of slot consuming instances to which slots are attributed in a given time frame, and accordingly is set to zero at the start of a new time frame.

In one embodiment, a time frame may be any length of time, such as 1 hour, 1 day, 1 week, etc. Furthermore, in the case of a 1 day time frame, the time frame may begin anew at 12:00 AM each day, according to one embodiment.

The method 300 next proceeds to operation 310, whereupon a license use signature is determined from recorded license attribution information. A notification of an instance not yet attributed to a license is waited for, and when a license fitting this criteria is found, it is received at operation 320, upon which the method 300 proceeds to operation 330. In operation 330, the new instance is attributed to one of the licenses as a function of the license use signature, which is generated at operation 310. At operation 350, the method 300 then determines whether the end of the time frame has been reached, or whether it has not been reached. In a case where the end of the time frame has been reached, the method 300 returns to operation 305, and N is reset to 0. Otherwise, the method 300 returns to operation 310, where the license use signature is updated to reflect the new usage situation. Of course, this is merely one embodiment of a method that may be used to more efficiently attribute and assign licenses to instances of an application. More or less operations may be included in method 300, as would be apparent to one of skill in the art upon reading the present descriptions.

FIG. 4 is a detailed schematic representation of a method 400, according to one embodiment. The method 400 includes and expands upon method 300 from FIG. 3. Referring again to FIG. 4, the method 400 comprises the same basic steps 305, 310, 320, 330, and 350 as described above with respect to FIG. 3, with further optional sub-operations or sub-steps being provided within operations 310 and 330, according to one embodiment.

In particular, according to method 400, operation 310 for determining the license use signature starts at operation 411 for loading license attribution information. The method 400 then proceeds to operation 412, which includes operation 413 for determining from the recorded license attribution information a probability for each license that an arbitrary instance will be chargeable according to that license, a value which is accorded a symbol (C), and operation 414 for determining from the recorded license attribution information for each license of the plurality of licenses an average number of slots consumed per instance, which is accorded a symbol (S). These two operations 413, 414 may of course be carried out in any order, in parallel, using different processors, etc.

In addition, as shown in FIG. 4, operation 330 starts with operation 431 for extracting instance attributes. Instance attributes may include information identifying the software or application being instantiated, a user, an environment in which the software or application is being instantiated, and/or any other information useful to identify suitable licenses providing rights covering the instantiated software or application as described herein according to various embodiments.

Based on this information at operation 432, the method 400 proceeds to select candidate licenses providing rights covering the instantiated software or application, from which the optimum or best license to attribute to the new instance is selected, in one approach. At operation 433 the method 400 selects the first candidate license, L=1. At operation 434, it is determined whether the probability for the presently selected candidate license that a new instance will be chargeable according to that license (C) multiplied by the average number of slots consumed per instance (S) for that license multiplied by the number of instances already attributed to that license during the present time frame (I) is less than the entitlement value (E) for that license, e.g., E>C*S*I. If the entitlement value (E) is greater than this calculated value, e.g., C*S*I, the method 400 proceeds to operation 435.

At operation 435, it is determined whether the probability that an arbitrary instance will be chargeable according to the presently selected license (C) is the lowest of the candidate licenses yet reviewed, e.g., the probability that an arbitrary instance will be chargeable according to the presently selected license (C) for the currently selected license is less than the probability (C) calculated for all other licenses tested. If it is, the license is earmarked or somehow indicated as the strongest candidate so far reviewed at operation 436, before proceeding to operation 437.

In a case whether either the test of operation 434 or 435 fails, the method 400 proceeds directly to operation 437. In any case, at operation 437, it is determined whether the license presently under review is the last of the candidate licenses or not. If not, the value of L is incremented by one at operation 438, thereby proceeding to the review of the next candidate license at operation 434 as described above. If the license presently under review is determined to be the last candidate license, the method 400 proceeds to operation 439 at which it is determined whether a license has been earmarked as suitable or not.

If a license has been earmarked as suitable, the method 400 proceeds to operation 441 where the slots required by the new instance are attributed to the earmarked license. The method then increments N at operation 442 before reaching operation 350 as described herein. In a case where no license has been earmarked, the method 400 proceeds to operation 440 where the instance is flagged as unlicensed.

Optionally, in one approach, this may lead to the instance being terminated or refused resources. Alternatively, notifications may be transmitted, for example by email, text, SMS, etc., to appropriate personnel of the organization running the instance or the method to apprise them of this situation, such as IT staff, procurement staff, etc. Still further, a mechanism able to request an exception or emergency rights may be automatically put into operation, in another approach. The reaction may depend on the nature of the software or application itself, for example, as determined from the attributes collected at operation 431. In one example, if the instance is determined to relate to critical operations, the instance may be allowed to proceed unlicensed or under emergency conditions. The method 400 then proceeds reaching operation 350 as described herein.

In a case where a number of equal candidates are identified, other criteria may be used as tie breakers to choose a best license, as would be understood by one of skill in the art upon reading the present descriptions.

FIG. 5 shows a method 500 for license management, according to one embodiment. The method 500 may be carried out in any desired environment, including those shown in FIGS. 1-2 and 7, and may include more or less operations than those described in FIG. 5.

In operation 502, entitlement slots are arranged under a plurality of licenses, each entitlement slot being configured for affording entitlement to use of an instance of a software application during a particular time frame. Each license of the plurality of licenses may include a plurality of entitlement slots determined by a characteristic of the license, such as a maximum number of users, maximum number of processors, etc.

In operation 504, a license use signature is determined from recorded license attribution information. In one embodiment, the license use signature may be determined by determining a probability for each of the plurality of licenses that an arbitrary instance will be chargeable according to that license (C) and determining for each of the plurality of licenses an average number of slots consumed per instance (S). The license use signature may represent typical license use patterns, in one approach.

In operation 506, a notification is received indicating that an instance is not attributed to a license. This notification may be received from another system, from an OS running the application, or any other method, as would be understood by one of skill in the art.

In operation 508, the non-attributed instance is attributed to one of the plurality of licenses as a function of the license use signature. In one approach, each license may have an entitlement value (E) defining a maximum number of entitlement slots that may be attributed to that license during the time frame. In another approach, any given instance of the software application may consume any number of the entitlement slots, including 0 entitlement slots all the way up to infinity.

According to one approach, the attributing the non-attributed instance to one of the plurality of licenses (operation 508) may comprise at least one of: attributing the non-attributed instance to a most convenient of the licenses while ensuring compliance with terms of all of the plurality of licenses, and attributing the non-attributed instance to a license which has a lowest probability that an arbitrary instance will be chargeable according to that license (C), wherein the entitlement value for this license (E) is greater than the probability for this license that the non-attributed instance will be chargeable according to this license (C) multiplied by an average number of slots consumed per instance (S) for this license multiplied by a number of instances already attributed to this license during the time frame (I), such that E>C*S*I.

In another approach, the probability for each of the plurality of licenses that an arbitrary instance will be chargeable according to that license (C) is calculated as an average across all time frames in a historical record of a ratio between a number of slots consumed on each time frame comprised in the historical record (dC) and a number of instances to which slots are attributed in a same time frame (dN), such that C=AVG(dC/dN). The average number of slots consumed per instance (S) may be calculated as an average across all time frames in a historical record of a ratio between a number of instances to which slots are attributed in each time frame (dN) and a total number of instances attributed to that license in a same time frame (dN), such that S=AVG(dN/dL). Also, each license's entitlement value (E) may be multiplied by a protection threshold value (P) in order to reduce each license's entitlement value (E) to become less than a strict maximum predefined by each license. In another approach, a number of slots consumed by an instance may be related to a number of processors on which the instance is being executed.

FIG. 6 shows a schematic block diagram 600 of functional elements of some embodiments. As shown, there is provided a license attributor 650, which receives an instance notification represented by the input 601. On receiving this notification, the license attributor 650 issues instructions 651 to a repository of software licenses 610, to retrieve details of licenses relevant to the software being instantiated. Details of the retrieved licenses 611 are output to a license parser 620, which provides the entitlement value E to the second module of the license use signature builder as described hereafter in message 621, and submits a request 622 to a recorded license attribution information database 630 for historical information for the candidate licenses. This historical use information is passed in message 631 to the license use signature builder 640. A first module 641 of the license use signature builder calculates the values C, S, and N as described herein, and passes these to a second module 642 of the license use signature builder which for each license calculates the Residual capacity value (R) according to the calculation R(n)=E−N×C×S, as described herein. The license use signature builder 640 outputs a set of R values 643 and a set of C values 644 to the License attributor 650. According to this embodiment, the license use signature thus comprises R values and C values for each candidate license: The License attributor 650, on receiving this signature, selects the best candidate license as described herein according to various embodiments, and updates the recorded license attribution information database 630 using the message 652.

It will be appreciated by one of skill in the art that the functional elements described with respect to FIG. 6, and correspondingly the operations of the methods described with respect to FIGS. 3-5, as well as other embodiments, may be implemented in the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment including both hardware and software elements.

The preceding embodiments outline a situation where some instances have already been assigned to the license in the time frame and another instance is to be assigned. Hereafter, an alternative situation is considered wherein a licensing system computes the association between licenses and usage instances as a first step and then, based on the associated instances, calculates the license consumption. Under such circumstances, the R value cannot be computed as far as all the instances have been already associated. This means that the algorithm should calculate R as the historical residual capacity, for example how much capacity remained for a licenses in the previous calculation period. In this variation, after computing the historical R, the algorithm moves to associating consume instances to the licenses. For each session, the algorithm finds a suitable license: if the license is the same that was associated in the previous period, it is assigned without any further calculation (if in the previous day this assignment lead to a compliant license, the result will be the same also today). If the resulting license is not the one used the day before (also for example in case the consume session didn't occur in the previous period), at this point it is useful to consider R and calculate R−(consume session)*C*S, thus obtaining R′. The license with the largest R′ should be used. If another consume session is to be assigned to this license, calculate R″=R′−(usage session)*C*S, and so forth for each new instance that is to be assigned, where “new” means it was not assigned in the previous period.

In this embodiment, the protection threshold is especially significant since in this first phase instances are assigned based on statistical parameters computed on historical data to speed up the computations. But at the end of the period it will be useful to calculate the real consumption, making exact calculations. When performing the exact calculation, the system may discover it was too optimistic when assigning instances based on historical data, and so while computation based on historical data indicated no license was overused, in reality, when performing exact calculations, the assignment generates licenses overuse. For this reason, a protection factor is desirable, so that even if the results of exact calculations end up being worse than expected, a margin is available avoid overuse.

According to a further embodiment, rather than selecting the license with the lower C and a R higher than 0, the system may select whichever license has the largest residual capacity, because assigning based on C may have some side effects (for example, a license with a high C and a very low S may be preferable to a license with a low C but very high S).

According to a further embodiment, rather than selecting the license with the lower C and a R higher than 0, the system may select whichever license has a lower product between C and S. This approach provides additional strength to the algorithm because the probability that an instance will consume something is considered together with the cost if consumption occurs, so the probability of the worst case scenario is considered, i.e., the instance consumes, together with the penalty of paying in this worst case scenario, e.g., the mean expected consumption). In such an approach, the license use signature for each license may also include the value of S as described herein. By considering both C and S, both the probability of a charge and the “slot price” paid in case it is chargeable are taken into account. The multiplication of these two values will lead to how statistically expensive it would be for the association to a license.

According to another embodiment, in a case where the system is used to choose among two or more equally eligible licenses, for example two licenses having the same value of C, the system may use one of the alternative methods describe above as a tie-breaker.

Furthermore, embodiments described herein may take the form of a computer program product accessible from a computer-usable or computer-readable medium providing program code for use by or in connection with a computer or any instruction execution system. For the purposes of this description, a computer-usable or computer readable medium may be any apparatus that can include, store, communicate, propagate, and/or transport the program for use by or in connection with the instruction execution system, apparatus, or device.

FIG. 7 shows a computer environment 700 suitable for implementing embodiments described herein. As shown in FIG. 7, the computer system 700 comprises a processor 710, a main memory 720, a mass storage interface 730, a display interface 740, and a network interface 750. These system components are interconnected through the use of a system bus 701. Mass storage interface 730 is used to connect mass storage devices (e.g., hard disk drive 755) to the computer system 700. One specific type of removable storage interface drive 762 is a floppy disk drive 762 which may store data to and read data from a floppy disk 795, but may other types of computer readable storage medium may be envisaged, such as readable and optionally writable CD-ROM drive, DVD-ROM drive, optical drive, etc. There is similarly provided a User input interface 744 which receives user interactions from interface devices such as a mouse 765 and a keyboard 764. There is also provided a printer interface 746 which may send and optionally receive signals to and from a printer 766. Of course, a USB connection (not shown) may be used to connect to any number of peripheral devices, such as those described above and others known to one of skill in the art.

Main memory 720 in accordance with some embodiments includes data 722, and an operating system 724.

The computer system 700 utilizes well known virtual addressing mechanisms that allow the programs of the computer system 700 to behave as if they only have access to a large, single storage entity instead of access to multiple, smaller storage entities such as main memory 720 and HDD 755. Therefore, while data 722 and operating system 724 are shown to reside in main memory 720, those skilled in the art will recognize that these components are not necessarily all completely contained in main memory 720 at the same time. It should also be noted that the term “memory” is used herein to generically refer to the entire virtual memory of computer system 700.

Data 722 represents any data that serves as input to or output from any program in computer system 700. Operating system 724 may be a multitasking operating system known in the industry as OS/400 or some other version of an OS, such as WINDOWS, UNIX, etc., as those skilled in the art will appreciate that the spirit and scope of the present invention is not limited to any one operating system.

Processor 710 may be constructed from one or more microprocessors and/or integrated circuits. Processor 710 executes program instructions stored in main memory 720. Main memory 720 stores programs and data that processor 710 may access. When computer system 700 starts up, processor 710 initially executes the program instructions that make up operating system 724. Operating system 724 is a sophisticated program that manages the resources of computer system 700. Some of these resources are processor 710, main memory 720, mass storage interface 730, display interface 740, network interface 750, and system bus 701.

Although computer system 700 is shown to include only a single processor and a single system bus, those skilled in the art will appreciate that a computer system that has multiple processors and/or multiple buses may be used. In addition, the interfaces that are used in the embodiment shown each include separate, fully programmed microprocessors that are used to off-load compute-intensive processing from processor 710. However, those skilled in the art will appreciate that computer systems that simply use I/O adapters to perform similar functions may be used.

Display interface 740 is used to directly connect one or more displays 760 to computer system 700. These displays 760, which may be non-intelligent (i.e., dumb) terminals or fully programmable workstations, are used to allow system administrators and users to communicate with computer system 700. Note, however, that while display interface 740 is provided to support communication with one or more displays 760, computer system 700 does not necessarily require a display 765, because all needed interaction with users and other processes may occur via network interface 750.

Network interface 750 is used to connect other computer systems and/or workstations (e.g., 775 in FIG. 7) to computer system 700 across a network 770. Computer system 700 may be connected to other computer systems and/or workstations in any manner, regardless of whether the network connection 770 is made using present-day analogue and/or digital techniques or via some networking mechanism of the future. In addition, many different network protocols may be used to implement a network. These protocols are specialized computer programs that allow computers to communicate across network 770. Transmission Control Protocol/Internet Protocol (TCP/IP) is an example of a suitable network protocol, for example over an Ethernet network. As shown, the network 770 connects the system 700 to two further devices 771 and 772, which may be other computer systems similar to that described above, or other network capable devices such as printers, routers etc. In the present example, network device 772 is a local server, which is connected via a modem 781 to a public network 780 such as the word wide web (WWW). Using this public network 780, a connection to a remote device or system 785 may be established.

At this point, it is important to note that while the embodiments described herein have been and will continue to be described in the context of a fully functional computer system, those skilled in the art will appreciate that the embodiments described herein are capable of being distributed as a program product in a variety of forms, and that the embodiments described herein apply equally regardless of the particular type of signal bearing media used to actually carry out the distribution. Examples of suitable signal bearing media include: recordable type media such as CD-ROM (e.g., 795 of FIG. 7), DVD-ROM, Flash memory, etc., and transmission type media such as digital and analogue communications links.

While the embodiments described herein have been described in the context of attributing software licenses, it will be appreciated that they are capable of handling the attribution of any activity which may require selection from a number of different license agreements.

While various embodiments have been described above, it should be understood that they have been presented by way of example only, and not limitation. Thus, the breadth and scope of an embodiment of the present invention should not be limited by any of the above-described exemplary embodiments, but should be defined only in accordance with the following claims and their equivalents. 

1-12. (canceled)
 13. A system for license management, the system comprising: logic adapted for arranging entitlement slots under a plurality of licenses, each entitlement slot being configured for affording entitlement to use of an instance of a software application during a particular time frame; logic adapted for determining a license use signature from recorded license attribution information; logic adapted for receiving a notification of an instance not attributed to a license; and logic adapted for attributing the non-attributed instance to one of the plurality of licenses as a function of the license use signature, wherein each license has an entitlement value (E) defining a maximum number of entitlement slots that may be attributed to that license during the time frame, and wherein any given instance of the software application may consume any number of the entitlement slots including 0 entitlement slots.
 14. The system as recited in claim 13, wherein the license use signature represents typical license use patterns, and wherein the logic adapted for attributing the non-attributed instance to one of the plurality of licenses comprises logic adapted for attributing the non-attributed instance to a most convenient of the licenses while ensuring compliance with terms of all of the plurality of licenses.
 15. The system as recited in claim 13, wherein the logic adapted for determining a license use signature comprises: logic adapted for determining from the recorded license attribution information a probability for each of the plurality of licenses that an arbitrary instance will be chargeable according to that license (C); and logic adapted for determining from the recorded license attribution information for each of the plurality of licenses an average number of slots consumed per instance (S), wherein the logic adapted for attributing the non-attributed instance to one of the plurality of licenses comprises: logic adapted for attributing the non-attributed instance to a license which has a lowest probability that an arbitrary instance will be chargeable according to that license (C), wherein the entitlement value for this license (E) is greater than the probability for this license that the non-attributed instance will be chargeable according to this license (C) multiplied by an average number of slots consumed per instance (S) for this license multiplied by a number of instances already attributed to this license during the time frame (I), such that E>C*S*I.
 16. The system as recited in claim 15, wherein the probability for each of the plurality of licenses that an arbitrary instance will be chargeable according to that license (C) is calculated as an average across all time frames in a historical record of a ratio between a number of slots consumed on each time frame comprised in the historical record (dC) and a number of instances to which slots are attributed in a same time frame (dN), such that C=AVG(dC/dN).
 17. The system as recited in claim 15, wherein the average number of slots consumed per instance (S) is calculated as an average across all time frames in a historical record of a ratio between a number of instances to which slots are attributed in each tune frame (dN) and a total number of instances attributed to that license in a same time frame (dN), such that S=AVG(dN/dL).
 18. The system as recited in claim 15, wherein each license's entitlement value (E) is multiplied by a protection threshold value (P) in order to reduce each license's entitlement value (E) to become less than a strict maximum predefined by each license.
 19. The system as recited in claim 13, wherein the time frame is one day.
 20. The system as recited in claim 13, wherein the notification is generated by an operating system on which the application is running.
 21. The system as recited in claim 13, wherein a number of slots consumed by an instance is related to a number of processors on which the instance is being executed.
 22. A computer program product for license management, the computer program product comprising a non-transitory computer readable storage medium having computer readable program code embodied therewith, the computer readable program code comprising: computer readable program code configured for arranging entitlement slots under a plurality of licenses, each entitlement slot being configured for affording entitlement to use of an instance of a software application during a particular time frame; computer readable program code configured for determining a license use signature from recorded license attribution information; computer readable program code configured for receiving a notification of an instance not attributed to a license; and computer readable program code configured for attributing the non-attributed instance to one of the plurality of licenses as a function of the license use signature, wherein each license has an entitlement value (E) defining a maximum number of entitlement slots that may be attributed to that license during the time frame, and wherein any given instance of the software application may consume any number of the entitlement slots including 0 entitlement slots.
 23. The computer program product as recited in claim 22, wherein the license use signature represents typical license use patterns, and wherein the computer readable program code configured for attributing the non-attributed instance to one of the plurality of licenses comprises computer readable program code configured for attributing the non-attributed instance to a most convenient of the licenses while ensuring compliance with terms of all of the plurality of licenses.
 24. The computer program product as recited in claim 22, wherein the computer readable program code configured for determining a license use signature comprises: computer readable program code configured for determining from the recorded license attribution information a probability for each of the plurality of licenses that an arbitrary instance will be chargeable according to that license (C); and computer readable program code configured for determining from the recorded license attribution information for each of the plurality of licenses an average number of slots consumed per instance (S), wherein the computer readable program code configured for attributing the non-attributed instance to one of the plurality of licenses comprises: computer readable program code configured for attributing the non-attributed instance to a license which has a lowest probability that an arbitrary instance will be chargeable according to that license (C), wherein the entitlement value for this license (E) is greater than the probability for this license that the non-attributed instance will be chargeable according to this license (C) multiplied by an average number of slots consumed per instance (S) for this license multiplied by a number of instances already attributed to this license during the time frame (I), such that E>C*S*I.
 25. The computer program product as recited in claim 24, wherein the probability for each of the plurality of licenses that an arbitrary instance will be chargeable according to that license (C) is calculated as an average across all time frames in a historical record of a ratio between a number of slots consumed on each time frame comprised in the historical record (dC) and a number of instances to which slots are attributed in a same time frame (dN), such that C=AVG(dC/dN).
 26. The computer program product as recited in claim 24, wherein the average number of slots consumed per instance (S) is calculated as an average across all time frames in a historical record of a ratio between a number of instances to which slots are attributed in each time frame (dN) and a total number of instances attributed to that license in a same time frame (dN), such that S=AVG(dN/dL).
 27. The computer program product as recited in claim 24, wherein each license's entitlement value (E) is multiplied by a protection threshold value (P) in order to reduce each license's entitlement value (E) to become less than a strict maximum predefined by each license.
 28. The computer program product as recited in claim 22, wherein the time frame is one day.
 29. The computer program product as recited in claim 22, wherein the notification is generated by an operating system on which the application is running.
 30. The computer program product as recited in claim 22, wherein a number of slots consumed by an instance is related to a number of processors on which the instance is being executed.
 31. A method for license management, the method comprising: arranging entitlement slots under a plurality of licenses, each entitlement slot being configured for affording entitlement to use of an instance of a software application during a particular time frame; determining a license use signature from recorded license attribution information by determining a probability for each of the plurality of licenses that an arbitrary instance will be chargeable according to that license (C) and determining for each of the plurality of licenses an average number of slots consumed per instance (S), wherein the license use signature represents typical license use patterns; receiving a notification of an instance not attributed to a license; and attributing the non-attributed instance to one of the plurality of licenses as a function of the license use signature, wherein each license has an entitlement value (E) defining a maximum number of entitlement slots that may be attributed to that license during the time frame, and wherein any given instance of the software application may consume any number of the entitlement slots including 0 entitlement slots.
 32. The method as recited in claim 31, wherein the attributing the non-attributed instance to one of the plurality of licenses comprises at least one of: attributing the non-attributed instance to a most convenient of the licenses while ensuring compliance with terms of all of the plurality of licenses, and attributing the non-attributed instance to a license which has a lowest probability that an arbitrary instance will be chargeable according to that license (C), wherein the entitlement value for this license (E) is greater than the probability for this license that the non-attributed instance will be chargeable according to this license (C) multiplied by an average number of slots consumed per instance (S) for this license multiplied by a number of instances already attributed to this license during the time frame (I), such that E>C*S*I, wherein the probability for each of the plurality of licenses that an arbitrary instance will be chargeable according to that license (C) is calculated as an average across all time frames in a historical record of a ratio between a number of slots consumed on each tune frame comprised in the historical record (dC) and a number of instances to which slots are attributed in a same time frame (dN), such that C=AVG(dC/dN), wherein the average number of slots consumed per instance (S) is calculated as an average across all tune frames in a historical record of a ratio between a number of instances to which slots are attributed in each time frame (dN) and a total number of instances attributed to that license in a same time frame (dN), such that S=AVG(dN/dL), wherein each license's entitlement value (E) is multiplied by a protection threshold value (P) in order to reduce each license's entitlement value (E) to become less than a strict maximum predefined by each license, and wherein a number of slots consumed by an instance is related to a number of processors on which the instance is being executed. 